﻿#define _CRT_SECURE_NO_WARNINGS 1




//#include <iostream>
//#include <mutex>
//#include <condition_variable>
//#include <thread>
//#include "SmartPtr.h"
//
//using namespace std;



//class Solution {
//public:
//    Solution()
//    {
//        count++;
//        num += count;
//    }
//    int Sum_Solution(int n) {
//        Solution S[n];
//        return num;
//    }
//private:
//    static int num;
//    static int count;
//};
//int Solution::num = 0;
//int Solution::count = 0;
//
//
//
//
//
//
//class A {
//public:
//    A() {
//        _a += _b;
//        _b++;
//    }
//
//    static int _a;
//    static int _b;
//};
//
//int A::_a = 0;
//int A::_b = 1;
//
//
//class Solution {
//public:
//    int Sum_Solution(int n) {
//        A* p = new A[n];
//
//        return A::_a;
//    }
//};
//
//
//


// 0 
//class A
//{
//public:
//  A() :m_iVal(0) 
//  { 
//      test(); 
//  }
//
//  virtual void func() 
//  { 
//      std::cout << m_iVal << " "; 
//  }
//
//  void test() 
//  { 
//      func(); 
//  }
//
//public:
//
//  int m_iVal;
//
//};



//class B : public A
//{
//public:
//
//    B() 
//    { 
//        test(); 
//    }
//
//    virtual void func()
//    {
//        ++m_iVal;
//        std::cout << m_iVal << " ";
//    }
//};
//
//
//int main(int argc, char* argv[])
//{
//    A* p = new B;
//    p->test();
//
//    return 0;
//}
//




//
//class A
//{
//public:
//
//  void f() { cout << "A::f()" << endl; }
//
//  int a;
//};
//
//
//class B : public A
//
//{
//
//public:
//
//	void f(int a) { cout << "B::f()" << endl; }
//
//	int a;
//
//};
//
//
//
//int main()
//
//{
//
//	B b;
//
//	b.f();
//
//	return 0;
//
//}











//懒汉模式--- 使用的时候才会去实例化

//class Singleton
//{
//public:
//	static Singleton* getInstance()
//	{
//		if (_inst == nullptr)
//		{
//			_mtx.lock();
//			if (_inst == nullptr)
//			{
//				_inst = new Singleton;
//			}
//			_mtx.unlock();
//		}
//
//		return _inst;
//	}
//	
//	Singleton& operator=(const Singleton&) = delete;
//	Singleton(const Singleton&) = delete;
//	
//private:
//	Singleton()
//	{}
//	static Singleton* _inst;
//	static mutex _mtx;
//};
//
//Singleton* Singleton::_inst = nullptr;
//mutex Singleton::_mtx;
//
//
//int main()
//{
//	cout << Singleton::getInstance() << endl;
//	cout << Singleton::getInstance() << endl;
//	cout << Singleton::getInstance() << endl;
//	cout << Singleton::getInstance() << endl;
//	cout << Singleton::getInstance() << endl;
//	cout << Singleton::getInstance() << endl;
//	return 0;
//}
//



////饿汉模式--- 程序启动的时候初始化
//class Singleton
//{
//public:
//	static Singleton& getInstance()
//	{
//		return _inst;
//	}
//
//	Singleton& operator=(const Singleton&) = delete;
//	Singleton(const Singleton&) = delete;
//
//private:
//	Singleton()
//	{}
//
//
//	static Singleton _inst;
//};
//
//Singleton Singleton::_inst;




//int main()
//{
//	cout << &(Singleton::getInstance()) << endl;
//	cout << &(Singleton::getInstance()) << endl;
//	cout << &(Singleton::getInstance()) << endl;
//	cout << &(Singleton::getInstance()) << endl;
//
//
//	Singleton& s1 = Singleton::getInstance();
//	Singleton& s2 = Singleton::getInstance();
//	Singleton& s3 = Singleton::getInstance();
//
//	cout << &s1 << endl;
//	cout << &s2 << endl;
//	cout << &s3 << endl;
//	return 0;
//}

















//void test1()
//{
//	auto_ptr<int> p1(new int(1));
//	auto_ptr<int> p2(new int(3));
//
//	cout << *p2 << endl;
//	cout << *p1 << endl;
//
//	p1 = p2;
//	auto_ptr<int> p3(p1);
//}
//
//
//void test2()
//{
//	unique_ptr<int> p1(new int(1));
//	unique_ptr<int> p2(new int(2));
//	p1 = p2;
//	unique_ptr<int> p3(p1);
//}
// 
//void test3()
//{
//	shared_ptr<int> p1(new int(3));
//	shared_ptr<int> p2(p1);
//
//	shared_ptr<int> p3(new int(5));
//}






//int main()
//{
//	//test1();
//	//test3();
//	
//	mutex _mtx;
//	condition_variable _con;
//	bool flag = true; // ture--线程1先走， false---线程2 先走
//	int x = 0;
//
//	thread t1([&]() {
//		while (x <= 99)
//		{
//			unique_lock<mutex> lock(_mtx);
//
//			while (!flag)
//				_con.wait(lock);
//
//			cout << "线程1: " << x << endl;
//			flag = false;
//			++x;
//
//			_con.notify_all();
//		}
//	});
//
//	thread t2([&]() {
//		while (x <= 99)
//		{
//			unique_lock<mutex> lock(_mtx);
//
//			while (flag)
//				_con.wait(lock);
//
//			cout << "线程2: " << x << endl;
//			flag = true;
//			++x;
//			_con.notify_all();
//		}
//	});
//	
//
//	t1.join();
//	t2.join();
//
//	return 0;
//}



//class Base {
//public:
//	virtual void func1() { cout << "Base::func1" << endl; }
//	virtual void func2() { cout << "Base::func2" << endl; }
//private:
//	int a;
//};
//
//
//class Derive :public Base
//{
//public:
//	virtual void func1() { cout << "Derive::func1" << endl; }
//	virtual void func3() { cout << "Derive::func3" << endl; }
//	virtual void func4() { cout << "Derive::func4" << endl; }
//private:
//	int b;
//};
//
//
//
//typedef void (*VFPTR)();            //把函数指针重命名为VFPTR
//void PrintTable(VFPTR VTABLE[])
//{
//	cout << "虚表地址->" << VTABLE << endl;
//	for (int i = 0; VTABLE[i] != nullptr; i++)
//	{
//		printf("第%d个虚函数地址: 0x%x,->", i, VTABLE[i]);
//		VFPTR f = VTABLE[i];
//		f();
//	}
//
//	cout << endl;
//}

//
//int main()
//{
//	Base b;
//	Derive d;
//
//	VFPTR* vtableb = (VFPTR*)(*(int*)&b);
//	//PrintTable(vtableb);
//
//	VFPTR* vtabled = (VFPTR*)(*(int*)&d);
//	//PrintTable(vtabled);
//
//	return 0;
//}
//
//
//
//
//
//
//
//void rotate(int* nums, int numsSize, int k)
//{
//	int j = 0;
//	int v = 0;
//	int s = 0;
//	k %= numsSize;
//
//	int* temp1 = (int*)malloc(sizeof(int) * numsSize);//用来存储待轮转的数组块
//	int* temp2 = (int*)malloc(sizeof(int) * numsSize);//用来存储未轮转的数组块
//
//	for (int i = numsSize - k; i < numsSize; i++)
//	{
//		temp1[j++] = nums[i];
//	}
//	// j == 4
//	for (int i = 0; i < numsSize - k; i++)
//	{
//		temp2[s++] = nums[i];
//	}
//
//
//	for (int i = 0, s = 0; i < numsSize; i++)
//	{
//		if (i < numsSize - j)
//			nums[i] = temp1[v++];
//		else
//			nums[i] = temp2[s++];
//	}
//}

//#include<stdlib.h>
//void rotate(int* nums, int numsSize, int k)
//{
//    int j = 0;
//    int v = 0;
//    int s = 0;
//    k %= numsSize;
//
//    int* temp1 = (int*)malloc(sizeof(int) * numsSize);//用来存储待轮转的数组块
//    int* temp2 = (int*)malloc(sizeof(int) * numsSize);//用来存储未轮转的数组块
//
//    for (int i = numsSize - k; i < numsSize; i++)
//    {
//        temp1[j++] = nums[i];
//    }
//    // j == 4
//    for (int i = 0; i < numsSize - k; i++)
//    {
//        temp2[s++] = nums[i];
//    }
//
//
//    for (int i = 0,s = 0; i < numsSize; i++)
//    {
//        if (i < numsSize - j)
//            nums[i] = temp1[v++];
//        else
//            nums[i] = temp2[s++];
//    }
//}

//
//int main()
//{/*
//    int arr[7] = { 1,2,3,4,5,6,7 };
//    rotate(arr,7,3);
//
//    for (int i = 0; i < 7; i++)
//    {
//        printf("%d ",arr[i]);
//    }*/
//
//    int a = 0;
//    int b = 0;
//    scanf("%d, %d", &a, &b);
//    cout << a << endl;
//    cout << b << endl;
//
//
//    return 0;
//}





#include <iostream>
#include <vector>
using namespace std;



int main(void)
{
    vector<vector<int>> v(10);
    /*vector<int> array;
    array.push_back(100);
    array.push_back(300);
    array.push_back(300);
    array.push_back(300);
    array.push_back(300);
    array.push_back(500);
    vector<int>::iterator itor;
    for (itor = array.begin(); itor != array.end(); itor++)
    {
        if (*itor == 300)
        {
            array.erase(itor);
        }
    }

    for (itor = array.begin(); itor != array.end(); itor++)

    {

        cout << *itor << " ";

    }*/

    return 0;

}